/*
    * GRIDIdentityMappingServiceExampleImpl.java
    *
    * Created on January 5, 2005, 6:00 PM
    */
   
   package org.opensciencegrid.authz.service;
   
   import java.util.StringTokenizer;
  import java.util.ArrayList;
  import java.util.Enumeration;
  import java.io.IOException;
  import java.io.BufferedReader;
  import java.io.InputStreamReader;
  import java.io.InputStream;
  import java.io.FileInputStream;
  
  import org.opensciencegrid.authz.common.GridId;
  import org.opensciencegrid.authz.common.LocalId;
  
  import org.apache.log4j.Category;
  
  /***
   * An example simple mapping service implementation that 
   * maps an incoming request based on
   * /etc/grid-security/grid-mapfile
   *
   * @author G. Carcassi, M. Lorch
   */
  
  
  
  public class GRIDIdentityMappingServiceExampleImpl implements GRIDIdentityMappingService {
  
      /*** Log4Java logger */
      static Category log = Category.getInstance(GRIDIdentityMappingServiceExampleImpl.class.getName() );
  
      /*** the standard Gridmap file location */
      private static String STDMAPFILE = "/etc/grid-security/mapsvc-gridmap";
  
      /*** the comment chars for the gridmap file */
      private static final String COMMENT_CHARS = "#";
  
      /*** the contents of the gridmap file, parsed at object instantiation */
      private ArrayList mappings;
  
      /*** internal format to hold gridmap entries */
      private class MapEntry extends LocalId {
         String subjectDN;
         String fqan;
         public void setSubjectDN(String s) {this.subjectDN = s;}
         public String getSubjectDN() {return this.subjectDN;}
         public void setFQAN(String f) {this.fqan = f;}
         public String getFQAN() {return this.fqan;}
         public String toString() {
           String r = subjectDN+" "+getUserName()+" "+fqan+" "+getGroupName()+" ";
           String[] gs = getSupplementalGroupNames();
           if(gs!=null) {
             for(int i=0;i<gs.length;i++) 
               r = r.concat(gs[i]+" ");
           }
           return r;
         }
      }
  
      /*** initialization method parses gridmap file 
       * gridmap file location may be supplied via system property gridmap.file 
       */
      public void init() {
         String mapfile = System.getProperty("gridmap.file");
         if(mapfile!=null) 
            log.debug("Parsing gridmap file from: "+mapfile);
         else {
            mapfile=STDMAPFILE;
            log.debug("System property gridmap.file not available");
            log.debug("Parsing gridmap file from standard location: "+mapfile);
         }
         try {
            mappings = parseMappingFile(mapfile);
         } catch (Exception e) {
            log.error("Unable to parse gridmap file: "+e);
            log.debug(e);
         }
         if(mappings==null || mappings.isEmpty()) log.debug("No gridmap entries were retrieved from gridmap file");
         else log.debug("Gridmap table loaded: "+mappings);
      }
  
      /*** the main function called from the outside, please note that
        * this is a test implementation
        * the host name of the service for which a mapping is being 
        * requested is not checked, neither is the issuer of the VOMS
        * attribute (fqan) considered
        */
      public LocalId mapCredentials(GridId gridID) {
          log.debug("entered mapCredentials of mapping service");
          MapEntry m;
  
          if(mappings==null) init(); // try to load mappings the first time around
  
         if(mappings==null) {
            log.debug("mapping table is empty, returning null (deny)");
            return null;  
         }
 
         log.debug("attempting to find a mapping");
 
         for(int i=0;i<mappings.size();i++) {
           m = (MapEntry) mappings.get(i);
           log.debug("comparing "+m.getSubjectDN()+" to "+gridID.getUserDN());
           if (m.getSubjectDN().equals(gridID.getUserDN()) ) {
             log.debug("found matching subject DN in gridmap table");
             // are fqan's present, if not we have a match
             if(m.getFQAN()==null && gridID.getUserFQAN()==null)  {	
                  log.debug("no FQANS, returning mapping for local user: "+m.getUserName());
                  return (LocalId) m; 
             }
             // if only one present, then continue, no match
             if(m.getFQAN()==null || gridID.getUserFQAN()==null) {
                  log.debug("FQANs don't match for this entry (null)");
                  continue;
             }
             // both are present, if they match then return 
             if(m.getFQAN().equals(gridID.getUserFQAN())) {
                  log.debug("FQAN matches, returning mapping for local user: "+m.getUserName());
                  return (LocalId) m;
             }
             else {
                  log.debug("FQANs don't match for this entry");
             }   
 
           } // end if m.getSubject
 
         } // end for
          
         log.debug("returning null, no valid mapping could be found");
         return null;
 
     } // end mapCredentials
 
 
     /*** file parser function that returns an array of localID objects 
       * function is tuned for configurations with up to 50 entries
       * it can parse standard GLOBUS gridmap files as well as gridmap
       * files that also contain fqan, group, and supplemental group 
       * fields (in that order)
       * It DOES NOT support multiple local user names (separated via a comma)
       */
     private ArrayList parseMappingFile(String mfile) 
      throws IOException {
 
      InputStream in = null;
      String line;
      ArrayList mappings = new ArrayList(50);
      MapEntry m;
      QuotedStringTokenizer tokenizer;
 
      in = new FileInputStream(mfile);
      
      BufferedReader reader =
             new BufferedReader(new InputStreamReader(in));
 
      while( (line = reader.readLine()) != null) {
         line = line.trim();
         if ( (line.length() == 0) ||
                ( line.substring(0, 1).indexOf(COMMENT_CHARS) != -1) ) {
             continue;
         }
         // ok, line is not a comment
         
         m = new MapEntry();
 
         tokenizer = new QuotedStringTokenizer(line);
 
         if (tokenizer.hasMoreTokens()) {
             m.setSubjectDN(tokenizer.nextToken());
         } else {
             throw new IOException("Subject DN not defined: " + line);
         }
         if (tokenizer.hasMoreTokens()) {
             m.setUserName(tokenizer.nextToken());
         } else {
             throw new IOException("Local user name not defined: " + line);
         }
         if (tokenizer.hasMoreTokens()) { //optional fqan
             m.setFQAN(tokenizer.nextToken());
         }
         if (tokenizer.hasMoreTokens()) { // optional primary group 
             m.setGroupName(tokenizer.nextToken());
         }
         // remainder are supplemental group names 
         if (tokenizer.hasMoreTokens()) { // optional suppl. group 
            ArrayList sg = new ArrayList(16); 
            while(tokenizer.hasMoreTokens() ) {
               sg.add(tokenizer.nextToken());
            }
            if(!sg.isEmpty()) { // we have suppl. groups
               String [] sglist = new String[sg.size()];
               for(int i=0;i<sg.size();i++) {
                 sglist[i]=(String)sg.get(i);
               }
               m.setSupplementalGroupNames(sglist);
            }
         }
 
         // done parsing the file, add the mapentry to our result
         // at least the userid and the subjectDN must be set (otherwise we threw exception)
       
         mappings.add(m);
 
      } // end while line reader
  
      // close file
      if (in != null) in.close();
         
      return mappings;
    } // end parseMappingFile
 
 
 } // end class
 
 
 /*
  * This class was snatched from org.globus.util (old cog kit version)
  * This class is not thread safe.
  */
 
 class QuotedStringTokenizer implements Enumeration {
 
     private int limit;
     private int start;
     private String str;
 
     public QuotedStringTokenizer(String str) {
         this.str = str;
         start = 0;
         limit = str.length();
     }
 
     public Object nextElement() {
         return nextToken();
     }
 
    public String nextToken() {
         while ((start < limit) && (str.charAt(start) <= ' ')) {
             start++;    // eliminate leading whitespace
         }
 
         if (start == limit) return null;
 
         StringBuffer buf = new StringBuffer(limit-start);
         char ch;
         char quote = str.charAt(start);
         if (quote == '"' || quote == '\'') {
             start++;
             for (int i=start;i<limit;i++) {
                 ch = str.charAt(i);
                 start++;
                 if (ch == quote) {
                     break;
                 } else if (ch == '//') {
                     buf.append( str.charAt(++i) );
                     start++;
                 } else {
                     buf.append(ch);
                 }
             }
             return buf.toString();
         } else {
             for (int i=start;i<limit;i++) {
                 ch = str.charAt(i);
                 start++;
                 if (ch == ' ') {
                     break;
                 } else {
                     buf.append(ch);
                 }
             }
         }
 
        return buf.toString();
     }
 
     public boolean hasMoreElements() {
         return hasMoreTokens();
     }
 
     public boolean hasMoreTokens() {
         while ((start < limit) && (str.charAt(start) <= ' ')) {
             start++;    // eliminate leading whitespace
         }
 
         return (start != limit);
     }
 
     public int countTokens() {
         int localStart = start;
         int i = 0;
         while( nextToken() != null ) {
             i++;
         }
         start = localStart;
         return i;
     }
 
 } // end quotedTokenizer class